package com.gzc.just.play.last.war.common.serializer;

import com.gzc.just.play.last.war.common.annotation.MessageDeserializer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 消息反序列化器注册表
 * 使用Map而不是switch-case来存储和查找反序列化器
 * 支持注解驱动的自动注册
 */
public class MessageDeserializerRegistry {
    private static final Logger logger = LoggerFactory.getLogger(MessageDeserializerRegistry.class);
    
    // 按模块分组的反序列化器映射
    private static final Map<String, Map<Integer, com.gzc.just.play.last.war.common.serializer.MessageDeserializer>> REGISTRY = 
        new ConcurrentHashMap<>();
    
    // 全局消息ID到模块的映射
    private static final Map<Integer, String> MESSAGE_ID_TO_MODULE = new ConcurrentHashMap<>();
    
    /**
     * 注册反序列化器
     * @param module 模块名称
     * @param messageId 消息ID
     * @param deserializer 反序列化器
     */
    public static void register(String module, int messageId, com.gzc.just.play.last.war.common.serializer.MessageDeserializer deserializer) {
        // 获取或创建模块的反序列化器映射
        Map<Integer, com.gzc.just.play.last.war.common.serializer.MessageDeserializer> moduleDeserializers = 
            REGISTRY.computeIfAbsent(module, k -> new ConcurrentHashMap<>());
        
        // 注册反序列化器
        moduleDeserializers.put(messageId, deserializer);
        MESSAGE_ID_TO_MODULE.put(messageId, module);
        
        logger.info("Registered deserializer for message ID {} in module {}", messageId, module);
    }
    
    /**
     * 使用注解注册反序列化器
     * @param deserializerClass 反序列化器类
     */
    public static void register(Class<?> deserializerClass) {
        MessageDeserializer annotation = deserializerClass.getAnnotation(MessageDeserializer.class);
        if (annotation == null) {
            logger.warn("Class {} is not annotated with @MessageDeserializer", deserializerClass.getName());
            return;
        }
        
        try {
            // 创建反序列化器实例
            com.gzc.just.play.last.war.common.serializer.MessageDeserializer deserializer = 
                (com.gzc.just.play.last.war.common.serializer.MessageDeserializer) deserializerClass.getDeclaredConstructor().newInstance();
            
            // 获取注解信息
            int messageId = annotation.messageId();
            Class<?> messageType = annotation.messageType();
            String module = annotation.module();
            
            // 如果没有指定模块，从类名推断
            if (module.isEmpty()) {
                String className = deserializerClass.getSimpleName();
                if (className.startsWith("Gate")) {
                    module = "gate-server";
                } else if (className.startsWith("Test")) {
                    module = "test-client";
                } else if (className.startsWith("Scene")) {
                    module = "scene-server";
                } else if (className.startsWith("Login")) {
                    module = "login-server";
                } else if (className.startsWith("Balance")) {
                    module = "balance-server";
                } else {
                    module = "unknown";
                }
            }
            
            // 注册反序列化器
            register(module, messageId, deserializer);
            
        } catch (Exception e) {
            logger.error("Failed to register deserializer class: " + deserializerClass.getName(), e);
        }
    }
    
    /**
     * 获取指定模块和消息ID的反序列化器
     * @param module 模块名称
     * @param messageId 消息ID
     * @return 反序列化器，如果不存在则返回null
     */
    public static com.gzc.just.play.last.war.common.serializer.MessageDeserializer getDeserializer(String module, int messageId) {
        Map<Integer, com.gzc.just.play.last.war.common.serializer.MessageDeserializer> moduleDeserializers = REGISTRY.get(module);
        if (moduleDeserializers == null) {
            return null;
        }
        return moduleDeserializers.get(messageId);
    }
    
    /**
     * 获取指定消息ID的反序列化器
     * @param messageId 消息ID
     * @return 反序列化器，如果不存在则返回null
     */
    public static com.gzc.just.play.last.war.common.serializer.MessageDeserializer getDeserializer(int messageId) {
        String module = MESSAGE_ID_TO_MODULE.get(messageId);
        if (module == null) {
            return null;
        }
        return getDeserializer(module, messageId);
    }
    
    /**
     * 检查指定模块是否支持指定消息ID
     * @param module 模块名称
     * @param messageId 消息ID
     * @return 是否支持
     */
    public static boolean supportsMessage(String module, int messageId) {
        Map<Integer, com.gzc.just.play.last.war.common.serializer.MessageDeserializer> moduleDeserializers = REGISTRY.get(module);
        if (moduleDeserializers == null) {
            return false;
        }
        return moduleDeserializers.containsKey(messageId);
    }
    
    /**
     * 检查是否有任何模块支持指定消息ID
     * @param messageId 消息ID
     * @return 是否支持
     */
    public static boolean supportsMessage(int messageId) {
        return MESSAGE_ID_TO_MODULE.containsKey(messageId);
    }
    
    /**
     * 获取指定模块支持的所有消息ID
     * @param module 模块名称
     * @return 消息ID数组
     */
    public static int[] getSupportedMessageIds(String module) {
        Map<Integer, com.gzc.just.play.last.war.common.serializer.MessageDeserializer> moduleDeserializers = REGISTRY.get(module);
        if (moduleDeserializers == null) {
            return new int[0];
        }
        
        int[] messageIds = new int[moduleDeserializers.size()];
        int i = 0;
        for (Integer messageId : moduleDeserializers.keySet()) {
            messageIds[i++] = messageId;
        }
        return messageIds;
    }
    
    /**
     * 清空注册表
     */
    public static void clear() {
        REGISTRY.clear();
        MESSAGE_ID_TO_MODULE.clear();
    }
}